diff --git a/CLAUDE.md b/CLAUDE.md
deleted file mode 100644
index 10c1d84..0000000
--- a/CLAUDE.md
+++ /dev/null
@@ -1,38 +0,0 @@
----
-description: Use Node.js with tsx/tsup for development and builds.
-globs: "*.ts, *.tsx, *.html, *.css, *.js, *.jsx, package.json"
-alwaysApply: false
----
-
-Default to using Node.js with tsx for TypeScript execution and tsup for bundling.
-
-- Use `tsx <file>` instead of `ts-node <file>` for running TypeScript files
-- Use `pnpm run build` (tsup) for bundling
-- Use `pnpm install` for installing dependencies
-- Use `pnpm run <script>` for running scripts
-- Use `pnpx <package> <command>` for one-off package execution
-
-## APIs
-
-- Use `node:http` createServer for HTTP servers
-- Use `node:fs/promises` for file operations (readFile, writeFile)
-- Use `node:child_process` spawn for subprocess execution
-- Use `node:crypto` for cryptographic operations
-
-## Build
-
-Use `tsup` for bundling. Configuration is in `tsup.config.ts`.
-
-```bash
-pnpm run build
-```
-
-## Development
-
-Run TypeScript files directly with tsx:
-
-```bash
-tsx index.ts
-```
-
-tsx automatically resolves path aliases from `tsconfig.json` (e.g. `@/*` → `./src/*`).
diff --git a/eslint.config.js b/eslint.config.js
index 538ca32..f6817c5 100644
--- a/eslint.config.js
+++ b/eslint.config.js
@@ -8,7 +8,7 @@ export default tseslint.config(
     languageOptions: { parser: tseslint.parser },
     plugins: { sonarjs },
     rules: {
-      "sonarjs/cognitive-complexity": ["error", 15]
+      "sonarjs/cognitive-complexity": ["error", 10]
     }
   }
 );
diff --git a/src/cli/commit.ts b/src/cli/commit.ts
index 18b3e7b..15e842a 100644
--- a/src/cli/commit.ts
+++ b/src/cli/commit.ts
@@ -1,6 +1,7 @@
 export { Commit };
 
 import * as p from "@clack/prompts";
+import * as pr from "@/infra/github/pr";
 import * as repo from "@/infra/git/repo";
 
 import { Future } from "@/libs/future";
@@ -11,6 +12,7 @@ import { resolveProvider } from "@/domain/llm/auth-resolver";
 import { generateCommitMessage, refineCommitMessage } from "@/domain/llm/router";
 import { Nothing, type Maybe, Just } from "@/libs/maybe";
 import { loading } from "@/infra/ui/spinner";
+import { renderPushNote } from "@/infra/ui/push-note";
 
 import color from "picocolors";
 
@@ -87,7 +89,26 @@ class Commit {
       : publish ? "Published successfully!"
       : "Pushed successfully!";
 
-    return loading(startMsg, endMsg, repo.performPush(branch, publish, forceWithLease)).map(() => {});
+    return loading(startMsg, endMsg, repo.performPush(branch, publish, forceWithLease)).chain((result) =>
+      Future.concurrently<
+        Error,
+        {
+          commit: repo.CommitMetadata;
+          localBranch: string;
+          upstream: Maybe<string>;
+          remoteUrl: string;
+          pr: pr.PrLookup;
+        }
+      >({
+        commit: repo.getCommitMetadata(),
+        localBranch: repo.getCurrentBranch(),
+        upstream: repo.getUpstream(),
+        remoteUrl: repo.getTrackingRemoteUrl(),
+        pr: pr.getOpenPullRequest()
+      })
+        .map((parts) => renderPushNote({ ...parts, range: result.range }))
+        .chainRej<Error>(() => Future.resolve(undefined))
+    );
   }
 
   interact(diff: string, message: string): Future<Error, void> {
diff --git a/src/domain/commit/prompts.ts b/src/domain/commit/prompts.ts
index 74107f1..aadf54a 100644
--- a/src/domain/commit/prompts.ts
+++ b/src/domain/commit/prompts.ts
@@ -51,6 +51,7 @@ function promptConventional(gitDiff: string): string {
           - You MAY use inline code formatting with single backticks, e.g. \`function_name\`, \`git diff\`.
           - Do NOT use multiline code fences (no \`\`\` blocks).
           - Keep language concise and concrete. Prefer what the change DOES over HOW it is implemented.
+          - End each bullet with a period for consistency with the project's existing history.
       </rules>
 
       <examples>
@@ -66,11 +67,39 @@ function promptConventional(gitDiff: string): string {
             +  console.log('[INFO]', new Date().toISOString(), message);
             }
           </git_diff>
-          <classification>SMALL</classification>
           <commit_message>
             feat(logger): add timestamp to info logs
           </commit_message>
         </example>
+
+        <example>
+          <git_diff>
+            // Multiple files, new function and wiring
+            diff --git a/tools/prompting.py b/tools/prompting.py
+            index 1111111..2222222 100644
+            --- a/tools/prompting.py
+            +++ b/tools/prompting.py
+            @@ -1,0 +1,40 @@
+            +def prompt_commit_message(git_diff: string) -> string:
+            +    \"\"\"Generate a commit message prompt from a git diff.\"\"\"
+            +    ...
+
+            diff --git a/tests/test_prompting.py b/tests/test_prompting.py
+            index 3333333..4444444 100644
+            --- a/tests/test_prompting.py
+            +++ b/tests/test_prompting.py
+            @@ -1,0 +1,25 @@
+            +def test_prompt_commit_message():
+            +    ...
+          </git_diff>
+          <commit_message>
+            feat(prompting): add prompt_commit_message for git diff analysis
+
+            - Add helper to generate commit messages from git diffs following the project guidelines.
+            - Include initial implementation of \`prompt_commit_message\` with unit tests covering basic usage.
+            - Wire the helper into the commit flow so diff inputs produce structured prompts.
+          </commit_message>
+        </example>
       </examples>
 
       <input>
@@ -84,7 +113,7 @@ function promptConventional(gitDiff: string): string {
         2. Do NOT output the classification (SMALL/MEDIUM/LARGE) in your response.
         3. Then output ONLY the final commit message text, with no explanation.
         4. Do NOT wrap the commit message in quotes or code fences.
-        5. Always start with a Conventional Commits type prefix and capitalize the first letter after the prefix.
+        5. Always start with a Conventional Commits type prefix. Use lowercase for the first word after the prefix (except for proper nouns and acronyms), matching the style of the examples.
         6. Respect the required format based on size:
           - SMALL: single line only.
           - MEDIUM/LARGE:
@@ -127,6 +156,7 @@ function promptImperative(gitDiff: string): string {
           - You MAY use inline code formatting with single backticks, e.g. \`function_name\`, \`git diff\`.
           - Do NOT use multiline code fences (no \`\`\` blocks).
           - Keep language concise and concrete. Prefer what the change DOES over HOW it is implemented.
+          - End each bullet with a period for consistency with the project's existing history.
       </rules>
 
       <examples>
@@ -144,7 +174,6 @@ function promptImperative(gitDiff: string): string {
             }
           </git_diff>
 
-          <classification>SMALL</classification>
           <commit_message>
             Update info logger to include timestamp
           </commit_message>
@@ -171,7 +200,6 @@ function promptImperative(gitDiff: string): string {
             +    ...
           </git_diff>
 
-          <classification>MEDIUM</classification>
           <commit_message>
             Add prompt_commit_message function for git diff analysis
 
@@ -229,6 +257,10 @@ function promptCustom(gitDiff: string, template: Maybe<string>): string {
         ${processedTemplate}
       </user_template>
 
+      <git_diff>
+        ${gitDiff}
+      </git_diff>
+
       <output_instructions>
         1. Follow the user's template style and format.
         2. Analyze the content and create a commit message that matches the template pattern.
@@ -254,6 +286,8 @@ function getRefinePrompt(params: { diff: string; currentMessage: string; adjustm
       `<adjustment>\n${params.adjustment}\n</adjustment>`,
     systemInstruction:
       "You revise commit messages. Use the diff and the user's adjustment to produce a polished commit message. " +
-      "Preserve required formatting rules: SMALL=single line; MEDIUM/LARGE=title, blank line, bullets prefixed with '- '."
+      "Preserve required formatting rules: SMALL=single line; MEDIUM/LARGE=title, blank line, bullets prefixed with '- '. " +
+      "Preserve the original convention: if the current message starts with a Conventional Commits prefix (feat, fix, refactor, chore, docs, style, test, perf, ci, build), keep it; otherwise keep the imperative style. " +
+      "Output ONLY the revised commit message. No preamble, no explanation, no code fences, no surrounding quotes."
   };
 }
diff --git a/src/infra/git/repo.ts b/src/infra/git/repo.ts
index a6adf23..3a568bb 100644
--- a/src/infra/git/repo.ts
+++ b/src/infra/git/repo.ts
@@ -1,85 +1,131 @@
-export { checkIsGitRepo, getStagedDiff, performCommit, performPush, getCurrentBranch, hasUpstream };
+export {
+  checkIsGitRepo,
+  getStagedDiff,
+  performCommit,
+  performPush,
+  getCurrentBranch,
+  hasUpstream,
+  getUpstream,
+  getCommitMetadata,
+  getRemoteUrl,
+  getTrackingRemoteUrl,
+  type CommitMetadata,
+  type PushResult,
+  type PushRange
+};
 
 import { Future } from "@/libs/future";
-import { spawn } from "node:child_process";
+import { Just, Nothing, type Maybe } from "@/libs/maybe";
+import { execBin } from "@/infra/shell";
 import { unlink, writeFile } from "node:fs/promises";
 import { tmpdir } from "node:os";
 import { join } from "node:path";
 
-const execGit = (args: string[]): Promise<{ stdout: string; stderr: string; exitCode: number }> =>
-  new Promise((resolve, reject) => {
-    const proc = spawn("git", args, { stdio: ["pipe", "pipe", "pipe"] });
-    let stdout = "";
-    let stderr = "";
-    proc.stdout.on("data", (d: Buffer) => (stdout += d.toString()));
-    proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()));
-    proc.on("error", reject);
-    proc.on("close", (exitCode) => resolve({ stdout, stderr, exitCode: exitCode ?? 1 }));
-  });
+type CommitMetadata = {
+  hash: string;
+  short: string;
+  subject: string;
+  authorName: string;
+  authorEmail: string;
+  date: Date;
+};
+
+type PushRange = { before: string; after: string };
+
+type PushResult = {
+  output: string;
+  range: Maybe<PushRange>;
+};
+
+const execGitChecked = (args: string[], fallbackMsg: string): Future<Error, string> =>
+  execBin("git", args).chain(({ stdout, stderr, exitCode }) =>
+    exitCode !== 0 ?
+      Future.reject<Error, string>(new Error(stderr.trim() || stdout.trim() || fallbackMsg))
+    : Future.resolve<Error, string>(stdout)
+  );
+
+const parsePushRange = (output: string): Maybe<PushRange> => {
+  const m = output.match(/([0-9a-f]{7,40})\.\.([0-9a-f]{7,40})/);
+  if (!m) return Nothing();
+  const [, before, after] = m;
+  return before && after ? Just({ before, after }) : Nothing();
+};
 
 const checkIsGitRepo = (): Future<Error, void> =>
-  Future.attemptP(async () => {
-    const { exitCode } = await execGit(["rev-parse", "--is-inside-work-tree"]);
-    if (exitCode !== 0) throw new Error("Not a git repository");
-  });
+  execGitChecked(["rev-parse", "--is-inside-work-tree"], "Not a git repository").map(() => {});
 
 const getStagedDiff = (): Future<Error, string> =>
-  Future.attemptP(async () => {
-    const { stdout, stderr, exitCode } = await execGit(["diff", "--staged"]);
-
-    if (exitCode !== 0) {
-      throw new Error(stderr.trim() || "Failed to get staged changes");
-    }
-
-    if (!stdout.trim()) throw new Error("No staged changes found");
-    return stdout;
-  });
+  execGitChecked(["diff", "--staged"], "Failed to get staged changes").chain((stdout) =>
+    stdout.trim() ?
+      Future.resolve<Error, string>(stdout)
+    : Future.reject<Error, string>(new Error("No staged changes found"))
+  );
+
+const performCommit = (message: string): Future<Error, string> => {
+  const tmpPath = join(tmpdir(), `commit-msg-${Date.now()}.txt`);
+  return Future.bracket(
+    Future.attemptP(() => writeFile(tmpPath, message, "utf-8")),
+    () => Future.attemptP(() => unlink(tmpPath).catch(() => {})),
+    () => execBin("git", ["commit", "-F", tmpPath])
+  ).chain(({ stdout, stderr, exitCode }) =>
+    exitCode !== 0 ?
+      Future.reject<Error, string>(new Error(stderr.trim() || stdout.trim() || "Commit failed"))
+    : Future.resolve<Error, string>(
+        "\n" +
+          stdout
+            .split("\n")
+            .filter((line) => !line.startsWith("["))
+            .join("\n")
+            .trim() +
+          "\n"
+      )
+  );
+};
+
+const performPush = (branch?: string, publish = false, forceWithLease = false): Future<Error, PushResult> => {
+  const args = publish && branch ? ["push", "--set-upstream", "origin", branch] : ["push"];
+  if (forceWithLease) args.push("--force-with-lease");
+  return execBin("git", args).chain(({ stdout, stderr, exitCode }) =>
+    exitCode !== 0 ?
+      Future.reject<Error, PushResult>(new Error(stderr.trim() || stdout.trim() || "Push failed"))
+    : Future.resolve<Error, PushResult>({
+        output: stdout + stderr,
+        range: parsePushRange(stdout + "\n" + stderr)
+      })
+  );
+};
 
-const performCommit = (message: string): Future<Error, string> =>
-  Future.attemptP(async () => {
-    const tmpPath = join(tmpdir(), `commit-msg-${Date.now()}.txt`);
-    await writeFile(tmpPath, message, "utf-8");
+const getCurrentBranch = (): Future<Error, string> =>
+  execGitChecked(["rev-parse", "--abbrev-ref", "HEAD"], "Failed to get current branch").map((s) => s.trim());
 
-    const { stdout, stderr, exitCode } = await execGit(["commit", "-F", tmpPath]);
+const hasUpstream = (): Future<Error, boolean> =>
+  execBin("git", ["rev-parse", "--abbrev-ref", "@{u}"]).map(({ exitCode }) => exitCode === 0);
 
-    await unlink(tmpPath).catch(() => {});
+const getUpstream = (): Future<Error, Maybe<string>> =>
+  execBin("git", ["rev-parse", "--abbrev-ref", "@{u}"]).map(({ stdout, exitCode }) =>
+    exitCode !== 0 ? Nothing<string>() : Just(stdout.trim())
+  );
 
-    if (exitCode !== 0) {
-      throw new Error(stderr.trim() || stdout.trim() || "Commit failed");
-    }
+const getRemoteUrl = (remote: string = "origin"): Future<Error, string> =>
+  execGitChecked(["remote", "get-url", remote], `Failed to read remote '${remote}' url`).map((s) => s.trim());
 
-    const stats = stdout
-      .split("\n")
-      .filter((line) => !line.startsWith("["))
-      .join("\n");
+const parseRemoteFromUpstream = (upstream: string): Maybe<string> => {
+  const idx = upstream.indexOf("/");
+  return idx > 0 ? Just(upstream.slice(0, idx)) : Nothing();
+};
 
-    return "\n" + stats.trim() + "\n";
+const getTrackingRemoteUrl = (): Future<Error, string> =>
+  getUpstream().chain((maybeRef) => {
+    const remote = maybeRef instanceof Just ? parseRemoteFromUpstream(maybeRef.value) : Nothing<string>();
+    return getRemoteUrl(remote instanceof Just ? remote.value : "origin");
   });
 
-const performPush = (branch?: string, publish = false, forceWithLease = false): Future<Error, string> =>
-  Future.attemptP(async () => {
-    const args = publish && branch ? ["push", "--set-upstream", "origin", branch] : ["push"];
-
-    if (forceWithLease) args.push("--force-with-lease");
-
-    const { stdout, stderr, exitCode } = await execGit(args);
-
-    if (exitCode !== 0) {
-      throw new Error(stderr.trim() || stdout.trim() || "Push failed");
+const getCommitMetadata = (ref: string = "HEAD"): Future<Error, CommitMetadata> =>
+  execGitChecked(["log", "-1", `--format=%H%n%h%n%s%n%an%n%ae%n%aI`, ref], "Failed to read commit metadata").chain(
+    (stdout) => {
+      const [hash, short, subject, authorName, authorEmail, iso] = stdout.split("\n");
+      return hash && short && subject !== undefined && authorName !== undefined && authorEmail !== undefined && iso ?
+          Future.resolve<Error, CommitMetadata>({ hash, short, subject, authorName, authorEmail, date: new Date(iso) })
+        : Future.reject<Error, CommitMetadata>(new Error("Malformed git log output"));
     }
-
-    return stdout || stderr;
-  });
-
-const getCurrentBranch = (): Future<Error, string> =>
-  Future.attemptP(async () => {
-    const { stdout, exitCode } = await execGit(["rev-parse", "--abbrev-ref", "HEAD"]);
-    if (exitCode !== 0) throw new Error("Failed to get current branch");
-    return stdout.trim();
-  });
-
-const hasUpstream = (): Future<Error, boolean> =>
-  Future.attemptP(async () => {
-    const { exitCode } = await execGit(["rev-parse", "--abbrev-ref", "@{u}"]);
-    return exitCode === 0;
-  });
+  );
diff --git a/src/infra/github/pr.ts b/src/infra/github/pr.ts
new file mode 100644
index 0000000..73bb6b4
--- /dev/null
+++ b/src/infra/github/pr.ts
@@ -0,0 +1,46 @@
+export { getOpenPullRequest, type PullRequest, type PrLookup };
+
+import * as repo from "@/infra/git/repo";
+import * as Decoder from "@/libs/json/decoder";
+
+import { Future } from "@/libs/future";
+import { Just, Nothing, type Maybe } from "@/libs/maybe";
+import { execBin } from "@/infra/shell";
+
+type PullRequest = { url: string; number: number };
+
+type PrLookup = { type: "found"; pr: PullRequest } | { type: "unauthenticated" } | { type: "unavailable" };
+
+const GITHUB_REPO_RE = /github\.com[:/]([^/\s]+\/[^/\s]+?)(?:\.git)?\/?$/;
+const GH_UNAUTH_RE = /not logged into|gh auth login|authentication required/i;
+
+const parseGithubRepo = (url: string): Maybe<string> => {
+  const m = url.match(GITHUB_REPO_RE);
+  return m && m[1] ? Just(m[1]) : Nothing();
+};
+
+const prDecoder: Decoder.Decoder<PullRequest> = Decoder.object({
+  url: Decoder.string,
+  number: Decoder.number
+});
+
+const parsePrJson = (stdout: string): PrLookup =>
+  Decoder.decode(stdout, Decoder.stringified(prDecoder)).either(
+    (): PrLookup => ({ type: "unavailable" }),
+    (pr): PrLookup => ({ type: "found", pr })
+  );
+
+const classifyFailure = (stderr: string): PrLookup =>
+  GH_UNAUTH_RE.test(stderr) ? { type: "unauthenticated" } : { type: "unavailable" };
+
+const getOpenPullRequest = (): Future<Error, PrLookup> =>
+  Future.both(repo.getTrackingRemoteUrl(), repo.getCurrentBranch())
+    .chain(([remoteUrl, branch]) => {
+      const slug = parseGithubRepo(remoteUrl);
+      return slug instanceof Just ?
+          execBin("gh", ["pr", "view", branch, "-R", slug.value, "--json", "url,number"]).map(
+            ({ stdout, stderr, exitCode }) => (exitCode !== 0 ? classifyFailure(stderr) : parsePrJson(stdout))
+          )
+        : Future.resolve<Error, PrLookup>({ type: "unavailable" });
+    })
+    .chainRej((): Future<Error, PrLookup> => Future.resolve({ type: "unavailable" }));
diff --git a/src/infra/shell.ts b/src/infra/shell.ts
new file mode 100644
index 0000000..e4e71dd
--- /dev/null
+++ b/src/infra/shell.ts
@@ -0,0 +1,20 @@
+export { execBin, type ExecResult };
+
+import { Future } from "@/libs/future";
+import { spawn } from "node:child_process";
+
+type ExecResult = { stdout: string; stderr: string; exitCode: number };
+
+const execBin = (bin: string, args: string[]): Future<Error, ExecResult> =>
+  Future.create<Error, ExecResult>((reject, resolve) => {
+    const proc = spawn(bin, args, { stdio: ["pipe", "pipe", "pipe"] });
+    let stdout = "";
+    let stderr = "";
+    proc.stdout.on("data", (d: Buffer) => (stdout += d.toString()));
+    proc.stderr.on("data", (d: Buffer) => (stderr += d.toString()));
+    proc.on("error", (err) => reject(err instanceof Error ? err : new Error(String(err))));
+    proc.on("close", (exitCode) => resolve({ stdout, stderr, exitCode: exitCode ?? 1 }));
+    return () => {
+      proc.kill();
+    };
+  });
diff --git a/src/infra/ui/push-note.ts b/src/infra/ui/push-note.ts
new file mode 100644
index 0000000..d7eb237
--- /dev/null
+++ b/src/infra/ui/push-note.ts
@@ -0,0 +1,51 @@
+export { renderPushNote, type PushMetadata };
+
+import * as p from "@clack/prompts";
+
+import type { CommitMetadata, PushRange } from "@/infra/git/repo";
+import type { PrLookup } from "@/infra/github/pr";
+import { Just, type Maybe } from "@/libs/maybe";
+import { absurd } from "@/libs/types";
+
+type PushMetadata = {
+  commit: CommitMetadata;
+  localBranch: string;
+  upstream: Maybe<string>;
+  remoteUrl: string;
+  range: Maybe<PushRange>;
+  pr: PrLookup;
+};
+
+const formatDate = (d: Date): string => d.toISOString().slice(0, 16).replace("T", " ");
+
+const renderPrLine = (lookup: PrLookup): string[] => {
+  switch (lookup.type) {
+    case "found":
+      return [`pr       #${lookup.pr.number} ${lookup.pr.url}`];
+    case "unauthenticated":
+      return [`pr       Tip: run 'gh auth login' to show open PR in the current branch...`];
+    case "unavailable":
+      return [];
+    default:
+      return absurd(lookup, "PrLookup");
+  }
+};
+
+const renderPushNote = (m: PushMetadata): void => {
+  const branchLine =
+    m.upstream instanceof Just ? `branch   ${m.localBranch} → ${m.upstream.value}` : `branch   ${m.localBranch}`;
+
+  const rangeLine = m.range instanceof Just ? [`range    ${m.range.value.before}..${m.range.value.after}`] : [];
+
+  const body = [
+    `commit   ${m.commit.short}  ${m.commit.subject}`,
+    `author   ${m.commit.authorName} <${m.commit.authorEmail}>`,
+    `date     ${formatDate(m.commit.date)}`,
+    branchLine,
+    `remote   ${m.remoteUrl}`,
+    ...rangeLine,
+    ...renderPrLine(m.pr)
+  ].join("\n");
+
+  p.note(body, "Pushed");
+};